{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAABECAYAAACmjMM7AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAACPElEQVR4nO3ZMYoTUQDG8ZdNSAJZdr1FzmApeBl7QVAP4DE8glhoIWxn4RFi5xViwJhMMhaxy2ZB/F7eEn6/dhj4qvnPmxn0fV8A4H9dtR4AwGUQFAAiBAWACEEBIGJ06sJ8Pu/KITjL880B4JG7KaXsF4vFUT9OBqUcYjKYTsa31WY1tutaL6irG+1bT6jqerBpPaGa1W7WekJV3XrVekJV09mk9YRqtuuulBNftx4KynI6Gd++fvWiyqjH4PuXyz583T3/0XpCVXdP3reeUM3Tr59bT6jq27tnrSdU9ebjy9YTqvnw9lPZrrt7H57+oQAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkCEoAAQISgARAgKABGCAkDEoO/7ey/M5/N9KWUwnYzPu+iMdl3rBXV1o33rCVVdDzatJ1Sz2s1aT6iqW69aT6hqOpu0nlDNdt2VUkq/WCyODiSjB+7bl1Ku1r83y1rDqGzXekBdPy/6gP2r9YCqhsNh6wlV/X3oXqqbcujDkZMnFAD4F5f8igfAGQkKABGCAkCEoAAQISgARPwB8K5NVoTYsCUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 504x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import math\n",
    "import matplotlib.ticker as ticker\n",
    "import statsmodels.formula.api as smf\n",
    "from pprint import pprint\n",
    "import re as re\n",
    "\n",
    "from statsmodels.regression.mixed_linear_model import MixedLMResults\n",
    "\n",
    "import scipy as sp\n",
    "#from scipy.stats import nanmean\n",
    "#from scipy.stats import nanstd\n",
    "import copy\n",
    "import scipy.stats as stats\n",
    "import string\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.cm as cm\n",
    "from pprint import pprint\n",
    "import seaborn as sns\n",
    "sns.set(style=\"white\", context=\"talk\")\n",
    "custom_palette = [ \"greyish\", \"dusty purple\", \"greenish\", \"amber\", \"windows blue\", \"black\",\"faded green\"]  \n",
    "                     #\"green blue\", \"dull green\", \"faded green\",  \n",
    "sns.set_palette(sns.xkcd_palette(custom_palette))\n",
    "current_palette = sns.color_palette()\n",
    "%matplotlib inline\n",
    "sns.palplot(current_palette)\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "game_rounds = pd.read_csv('./all_studies_game_data.csv')\n",
    "conditions = ['dynamic_full_feedback',\n",
    "              'dynamic',         \n",
    "              'dynamic_self_feedback',\n",
    "              'dynamic_no_feedback',\n",
    "              'static',\n",
    "              'solo_feedback',\n",
    "              'solo_no_feedback'\n",
    "             ]\n",
    "\n",
    "\n",
    "colors ={'dynamic_no_feedback':'#196FFF',\n",
    "         'dynamic_self_feedback':'#000000',\n",
    "         'dynamic_full_feedback':'#81B200',\n",
    "         'dynamic': '#81B200',\n",
    "         'static':'#9B59B6',\n",
    "         'solo_feedback': '#95A5A6',\n",
    "         'solo_no_feedback': '#95A5A6'\n",
    "        }\n",
    "\n",
    "\n",
    "linestyles ={'dynamic_no_feedback':'-.',\n",
    "         'dynamic_self_feedback':':',\n",
    "         'dynamic_full_feedback':'-',\n",
    "         'dynamic': '-',\n",
    "         'static':'--',\n",
    "         'solo_feedback': '-',\n",
    "         'solo_no_feedback': '-'\n",
    "        }\n",
    "\n",
    "markers ={'dynamic_no_feedback':'d',\n",
    "         'dynamic_self_feedback':'^',\n",
    "         'dynamic_full_feedback':'o',\n",
    "         'dynamic': 'o',\n",
    "         'static':'*',\n",
    "         'solo_feedback': 'H',\n",
    "         'solo_no_feedback': 'h'\n",
    "        }\n",
    "\n",
    "#markers = ['s','o','*']\n",
    "#linestyles = ['--','-',':','-.']\n",
    "tick_size = 25\n",
    "label_size = 35\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "studies = [1,2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# la buena\n",
    "# outcome variables:  avg(error)  ,   std(error)    \n",
    "# statistics:        only  avg[ ...  ]   ,  std[ ... ]   --> for error bars\n",
    "# unit of analysis:  game = >    avg_{games}[  avg_{rounds}(error)   ] ;\n",
    "    #                            avg_{games}[  std_{rounds}(error)   ] ;\n",
    "\n",
    "    \n",
    "    \n",
    "    \n",
    "def boot_condition_top_k_means_and_stds(b, condition, ks, wk_stats_boot, games_df, gids_condition, rids): \n",
    "    \n",
    "    ### make frame with repeated IDs;    \n",
    "    size = min(len(gids_condition), 20)                 # size = # games of condition, or 20\n",
    "    b_gids = np.random.choice(  gids_condition  , size= size, replace= True )\n",
    "    df_list = []\n",
    "    for i, gid in enumerate(b_gids):                                \n",
    "        bools = (games_df.condition == condition) & (games_df.game_id == gid) & (games_df.round_index.isin(rids))  # temporary for dealing with both frames\n",
    "        games_df['boot_id'] =  np.where( bools , i , games_df['boot_id'] )     # track repeated gids\n",
    "        df_list.append(  games_df[ bools ]  )    \n",
    "    games_sample_df = pd.concat(df_list, ignore_index=True) \n",
    "\n",
    "    ### compute statistics for each k\n",
    "    for k in ks:                                                        \n",
    "        col = \"top_\"+str(k)+'_rev_live';  means = []; stds = []\n",
    "        for i, gid in enumerate(b_gids): \n",
    "            bools = (games_sample_df.game_id==gid) & (games_sample_df.boot_id == i)\n",
    "            means.append( np.nanmean( games_sample_df[bools][col] ) )   # game average across rounds\n",
    "            stds.append(  np.nanstd ( games_sample_df[bools][col] ) )   # game variance across rounds\n",
    "\n",
    "        wk_stats_boot [condition][k][0].append( np.nanmean( means ) )   #  avg (game avgs.)\n",
    "        wk_stats_boot [condition][k][1].append( np.nanmean( stds  ) )   #  avg (game stds.) \n",
    "\n",
    "\n",
    "    \n",
    "    \n",
    "def wk_stats_CIs_and_SEs_2019(conds, df, n_boot = 100, rids = list(range(1,20+1))):\n",
    "    \n",
    "    np.random.seed(seed=0)\n",
    "    \n",
    "    games_df = df.copy(deep=True); games_df['boot_id'] = None;\n",
    "    ks = list( range(1, 12 +1 ) )  \n",
    "    #wk_stats_boot =   {'solo_feedback': [[],], 'static': [[],], 'dynamic': [[],] }\n",
    "    wk_stats_boot = {}\n",
    "    for condition in conds:   wk_stats_boot[condition] = [ [], ]\n",
    "\n",
    "    for condition in conditions:\n",
    "        \n",
    "        top_k_errors = {}\n",
    "        gids_condition = games_df[games_df.condition == condition].game_id.unique() # ids of the condition\n",
    "        for k in ks:   wk_stats_boot[condition].append( [ [] , [] ] )\n",
    "            \n",
    "        print(condition)\n",
    "\n",
    "        for b in range(0, n_boot):\n",
    "            print(\"Boot        \", b, \"  \", end='\\r')\n",
    "            boot_condition_top_k_means_and_stds(b, condition, ks, wk_stats_boot, games_df, gids_condition, rids)  #**           \n",
    "\n",
    "    \n",
    "    ################ mean estimates and confidence intervals ############## \n",
    "    low_p = 2.5              # 95% CIs\n",
    "    up_p  = 97.5\n",
    "    \n",
    "    # make dicts to save results\n",
    "    wk_stats, wk_cierrs, wk_SEs = {}, {}, {}\n",
    "    for condition in conds:   \n",
    "        wk_stats[condition] = [ [], ]; wk_cierrs[condition] = [ [], ]; wk_SEs[condition] = [ [], ]\n",
    "\n",
    "    # compute them\n",
    "    for condition in conditions:\n",
    "        for k in ks:  \n",
    "            wk_stats [condition].append([ [],[] ])            # means per objective \n",
    "            wk_cierrs [condition].append([ [],[],[],[] ])     # CIs per objective\n",
    "            wk_SEs [condition].append([ [],[] ])              # SEs per objective\n",
    "            means = wk_stats_boot[condition][k][0]            # bootstraped vectors\n",
    "            stds  = wk_stats_boot[condition][k][1]\n",
    "\n",
    "            wk_stats[condition][k][0] = np.mean( means )                          # mean of sampling dist.\n",
    "            wk_stats[condition][k][1] = np.mean( stds )                           # mean of sampling dist.\n",
    "            wk_SEs  [condition][k][0] = np.std( means )                           # std of sampling dist.\n",
    "            wk_SEs  [condition][k][1] = np.std( stds )                            # std of sampling dist.\n",
    "            wk_cierrs[condition][k][0] = abs( np.mean( means ) -  np.percentile( means , low_p ) )    # ci low bound\n",
    "            wk_cierrs[condition][k][1] = abs( np.mean( means ) -  np.percentile( means , up_p ) )     # ci up bound\n",
    "            wk_cierrs[condition][k][2] = abs( np.mean( stds ) -   np.percentile( stds ,  low_p ) ) \n",
    "            wk_cierrs[condition][k][3] = abs( np.mean( stds ) -   np.percentile( stds ,  up_p ) ) \n",
    "    #wk_cierrs['static'][1]\n",
    " \n",
    "    #pprint(wk_stats); pprint(wk_cierrs); pprint(wk_SEs)\n",
    "\n",
    "\n",
    "    ####### bootstraped p-values on selected comparissons: ################\n",
    "    if True:\n",
    "        wdn_vs_solok1_mean =    np.asarray(wk_stats_boot['dynamic'][12][0] ) -  np.asarray( wk_stats_boot['solo_feedback'][1][0])\n",
    "        wdn_vs_solok1_std =     np.asarray(wk_stats_boot['dynamic'][12][1] ) -  np.asarray( wk_stats_boot['solo_feedback'][1][1])\n",
    "        dynk1_vs_solok1_mean =  np.asarray(wk_stats_boot['dynamic'][1] [0] )  -  np.asarray( wk_stats_boot['solo_feedback'][1][0])\n",
    "        dynk1_vs_solok1_std =   np.asarray(wk_stats_boot['dynamic'][1] [1] )  -  np.asarray( wk_stats_boot['solo_feedback'][1][1])\n",
    "\n",
    "\n",
    "        # prints\n",
    "        print ( \"sum(wdn_vs_solok1_mean < 0)/ n_boot\", sum(wdn_vs_solok1_mean < 0)/ n_boot)\n",
    "        print ( \"sum(wdn_vs_solok1_std < 0)/ n_boot\",  sum(wdn_vs_solok1_std  < 0)/ n_boot)\n",
    "        print ( \"sum(dynk1_vs_solok1_mean < 0)/ n_boot\", sum(dynk1_vs_solok1_mean < 0)/ n_boot)\n",
    "        print ( \"sum(dynk1_vs_solok1_std < 0)/ n_boot\",  sum(dynk1_vs_solok1_std  < 0)/ n_boot)\n",
    "        print ( \"std of dyn-top-12 improves solo-top-1 by (%): \", np.mean( np.asarray(wk_stats_boot['dynamic'][12][1] ) )  / \n",
    "                np.mean( np.asarray( wk_stats_boot['solo_feedback'] [1] [1] ) ) - 1 )\n",
    "        print ( \"std of dyn-top-1 improves solo-top-1 by (%): \", np.mean( np.asarray(wk_stats_boot['dynamic'][1][1] ) )  / \n",
    "                np.mean( np.asarray( wk_stats_boot['solo_feedback']  [1] [1] ) ) - 1  )\n",
    "        print ( \"mean of dyn-top-12 improves solo-top-1 by (%): \", np.mean( np.asarray(wk_stats_boot['dynamic'][12][0] ) )  / \n",
    "                np.mean( np.asarray( wk_stats_boot['solo_feedback'] [1] [0] ) ) - 1 )\n",
    "        print ( \"mean of dyn-top-1 improves solo-top-1 by (%): \", np.mean( np.asarray(wk_stats_boot['dynamic'][1][0] ) )  / \n",
    "                np.mean( np.asarray( wk_stats_boot['solo_feedback']  [1] [0] ) ) - 1  )\n",
    "\n",
    "    \n",
    "    return wk_stats , wk_cierrs, wk_SEs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "solo_feedback\n",
      "solo_no_feedback   \n",
      "static       499   \n",
      "dynamic_self_feedback\n",
      "dynamic_no_feedback\n",
      "dynamic      499   \n",
      "dynamic_full_feedback\n",
      "sum(wdn_vs_solok1_mean < 0)/ n_boot 0.984\n",
      "sum(wdn_vs_solok1_std < 0)/ n_boot 1.0\n",
      "sum(dynk1_vs_solok1_mean < 0)/ n_boot 0.994\n",
      "sum(dynk1_vs_solok1_std < 0)/ n_boot 0.968\n",
      "std of dyn-top-12 improves solo-top-1 by (%):  -0.386630651427053\n",
      "std of dyn-top-1 improves solo-top-1 by (%):  -0.27074166208023953\n",
      "mean of dyn-top-12 improves solo-top-1 by (%):  -0.16392541205649147\n",
      "mean of dyn-top-1 improves solo-top-1 by (%):  -0.2389386467248854\n"
     ]
    }
   ],
   "source": [
    "conditions = [\n",
    "    'solo_feedback',\n",
    "    'solo_no_feedback',\n",
    "    'static',\n",
    "    'dynamic_self_feedback',\n",
    "    'dynamic_no_feedback',\n",
    "    'dynamic',\n",
    "    'dynamic_full_feedback',\n",
    "]\n",
    "\n",
    "\n",
    "\n",
    "n_boot = 500                                  # number of bootstrap cycles\n",
    "bars_type = 'CIs'                              # type of error bars to plot: CIs or SEs\n",
    "rids2= list(range(6,10+1)) + list(range(16,20+1))  # subset of rounds\n",
    "#rids2 = range(1,20+1)\n",
    "for i, rids in enumerate([rids2]):           # [rids0, rids1]):\n",
    "   \n",
    "    wk_stats , wk_cierrs, wk_SEs = wk_stats_CIs_and_SEs_2019( conditions, game_rounds , n_boot = n_boot, rids= rids)\n",
    "    \n",
    "#     tradeoff_plot_2019(conditions, wk_stats , wk_cierrs, bars=bars_type, wk_SEs=wk_SEs, \n",
    "#                   save=False, full=True, suffix='v2-b'+str(n_boot)+bars_type, markers=markers,colors=colors)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def tradeoff_plot_2019(conditions, wk_stats , wk_cierrs, ks= list(range(1, 12+1)), \n",
    "                       bars='CIs', wk_SEs=None,\n",
    "                       save=False, full=False , suffix='v', \n",
    "                       kks=[3,6,9], kkks=[1,12], annot=False,\n",
    "                       msize = 75,  ansep=.001, \n",
    "                       colors = ['darkkhaki', \"purple\", 'yellowgreen', 'teal', 'darkorange', \"olive\", \"blue\", \"mediumseagreen\" ],\n",
    "                       markers = ['o', '^', 's', 'o', '^', 's', 'o', '^', 's']):\n",
    "    \n",
    "    \n",
    "    fig = plt.figure(figsize=(9,9))\n",
    "    ax = fig.add_subplot(111)\n",
    "\n",
    "#     color_list = [ \"greyish\", \"dusty purple\", \"greenish\", \"amber\", \"windows blue\", \"black\",\"faded green\"]\n",
    "#     color_list = ['darkkhaki', \"purple\", 'yellowgreen', 'teal', 'darkorange', \"olive\", \"blue\", \"mediumseagreen\" ]\n",
    "#     #color_list = [ \"purple\", 'yellowgreen', 'teal', 'darkkhaki', 'darkorange', \"olive\", \"blue\", \"mediumseagreen\" ]\n",
    "    color_list = colors\n",
    "\n",
    "    wis_names = ['wisdom '+cond for cond in conditions]\n",
    "\n",
    "    \n",
    "    for i, condition in enumerate(conditions):\n",
    "        k_means = [wk_stats[condition][k][0] for k in ks ]\n",
    "        k_stds =  [wk_stats[condition][k][1] for k in ks ]\n",
    "        \n",
    "\n",
    "        if annot: \n",
    "            for j, k in enumerate(ks):\n",
    "                ax.annotate( str(k), xy=( k_means[j], k_stds[j] ) , fontsize= 8,\n",
    "                            xytext=( np.array(k_means[j]) +ansep, np.array(k_stds[j]) +ansep) )\n",
    "        \n",
    "        if  True:\n",
    "            for kk in kks:  \n",
    "                ax.scatter(wk_stats[condition][kk][0], wk_stats[condition][kk][1], \\\n",
    "                   s= msize, alpha= .7 ,  marker= markers[i], edgecolor='black', linewidth='.2',\n",
    "                   c = color_list[i]) \n",
    " \n",
    "        \n",
    "        if True:\n",
    "            for kkk in kkks:\n",
    "                \n",
    "                ax.scatter(wk_stats[condition][kkk][0], wk_stats[condition][kkk][1], \\\n",
    "                   s= msize, alpha= .93 , label= wis_names[i], marker=markers[i] , edgecolor='black', linewidth='.8',\n",
    "                   c = color_list[i], zorder=1) \n",
    "                \n",
    "                if bars:\n",
    "                    plt.errorbar(wk_stats[condition][kkk][0], wk_stats[condition][kkk][1], \n",
    "                                 markersize = .1 , fmt = 'o', alpha = .1 , color= color_list[i],\n",
    "                                 xerr= [ [wk_cierrs[condition][kkk][0] ], [wk_cierrs[condition][kkk][1] ] ] ,\n",
    "                                 yerr= [ [wk_cierrs[condition][kkk][2] ], [wk_cierrs[condition][kkk][3] ] ]  )\n",
    "                \n",
    "                ax.annotate( str(kkk), xy=( k_means[kkk-1], k_stds[kkk-1] ) , fontsize= 8,\n",
    "                                xytext=( np.array(k_means[kkk-1]) +ansep, np.array(k_stds[kkk-1]) +ansep),\n",
    "                           zorder=1)\n",
    "\n",
    "        \n",
    "\n",
    "\n",
    "    ax.xaxis.set_major_locator(ticker.MultipleLocator(0.05))\n",
    "    ax.yaxis.set_major_locator(ticker.MultipleLocator(0.05))\n",
    "\n",
    "    ax.tick_params(labelsize=30)\n",
    "    ax.set_xlim(0.049,0.201)\n",
    "    ax.set_ylim(0.049,0.15)\n",
    "\n",
    "    ax.set_xlabel(\"Average absolute error\",fontsize=35)\n",
    "    ax.set_ylabel(\"Variability [standard deviation]\", fontsize=35)\n",
    "    #plt.legend(loc='upper center', bbox_to_anchor=(0.5, 1.4), ncol=3)#, bbox_to_anchor=(0., -0.02, 1., -0.102), mode='expand' )\n",
    "\n",
    "    #plt.colorbar()\n",
    "    \n",
    "    if save: plt.savefig(suffix+'.pdf', \n",
    "                          dpi=200, bbox_inches='tight', format = 'pdf')\n",
    "    plt.show()\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#study 1\n",
    "\n",
    "\n",
    "conditions = [\n",
    "    'solo_feedback',\n",
    "    #'solo_no_feedback',\n",
    "    'static',\n",
    "    #'dynamic_self_feedback',\n",
    "    #'dynamic_no_feedback',\n",
    "    'dynamic',\n",
    "    #'dynamic_full_feedback',\n",
    "    #'dynamic_full_feedback_s12',\n",
    "]\n",
    "\n",
    "\n",
    "colors =['#95A5A6',\n",
    "         #'#3D797A',\n",
    "         '#9B59B6',\n",
    "         #'#000000',\n",
    "         #'#196FFF',\n",
    "         '#81B200',\n",
    "        ]\n",
    "\n",
    "markers =['H',\n",
    "          #'h',\n",
    "          '*',\n",
    "          'o']\n",
    "\n",
    "\n",
    "tradeoff_plot_2019(\n",
    "    conditions= conditions,\n",
    "    wk_stats=wk_stats,\n",
    "    wk_cierrs=wk_cierrs,\n",
    "    ks=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n",
    "    bars='CIs',\n",
    "    wk_SEs=wk_SEs,\n",
    "    save=False,\n",
    "    full=True,\n",
    "    suffix='study1_rev_live_true',\n",
    "    kks=[2,3,4,5,6,7,8,9,10,11], #[4, 9], #without error bars\n",
    "    kkks=[1,4,12], #with error bars\n",
    "    annot=False,\n",
    "    msize=350,\n",
    "    ansep=0.001,\n",
    "    colors=colors,\n",
    "    markers=markers,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#All together\n",
    "conditions = ['dynamic_full_feedback',\n",
    "              'dynamic',         \n",
    "              'dynamic_self_feedback',\n",
    "              'dynamic_no_feedback',\n",
    "              'static',\n",
    "              'solo_feedback',\n",
    "              'solo_no_feedback'\n",
    "             ]\n",
    "\n",
    "\n",
    "colors ={'dynamic_no_feedback':'#196FFF',\n",
    "         'dynamic_self_feedback':'#000000',\n",
    "         'dynamic_full_feedback':'#81B200',\n",
    "         'dynamic': '#81B200',\n",
    "         'static':'#9B59B6',\n",
    "         'solo_feedback': '#95A5A6',\n",
    "         'solo_no_feedback': '#95A5A6'\n",
    "        }\n",
    "\n",
    "\n",
    "\n",
    "markers ={'dynamic_no_feedback':'d',\n",
    "         'dynamic_self_feedback':'^',\n",
    "         'dynamic_full_feedback':'o',\n",
    "         'dynamic': 'o',\n",
    "         'static':'*',\n",
    "         'solo_feedback': 'H',\n",
    "         'solo_no_feedback': 'h'\n",
    "        }\n",
    "\n",
    "\n",
    "conditions = [\n",
    "    'solo_no_feedback',\n",
    "    'dynamic_self_feedback',\n",
    "    'dynamic_no_feedback',\n",
    "    'dynamic_full_feedback',\n",
    "    'solo_feedback',\n",
    "    'static',\n",
    "    'dynamic'\n",
    "    \n",
    "    \n",
    "]\n",
    "\n",
    "\n",
    "colors =['#3D797A',\n",
    "         '#000000',\n",
    "         '#196FFF',\n",
    "         '#E89468',\n",
    "         '#95A5A6',\n",
    "         '#9B59B6',\n",
    "         '#81B200'\n",
    "         \n",
    "        ]\n",
    "\n",
    "markers =['h',\n",
    "          '^',\n",
    "          'd',\n",
    "          'p',\n",
    "          \"H\",\n",
    "          '*',\n",
    "          'o'\n",
    "         ]\n",
    "\n",
    "\n",
    "tradeoff_plot_2019(\n",
    "    conditions= conditions,\n",
    "    wk_stats=wk_stats,\n",
    "    wk_cierrs=wk_cierrs,\n",
    "    ks=[1,2,3,4,5,6,7,8, 9,10,11,12],\n",
    "    bars='CIs',\n",
    "    wk_SEs=wk_SEs,\n",
    "    save=False,\n",
    "    full=True,\n",
    "    suffix='both_rev_live',\n",
    "    kks=[4,6], #[4, 9], #without error bars\n",
    "    kkks=[1, 4, 12], #with error bars\n",
    "    annot=False,\n",
    "    msize=350,\n",
    "    ansep=0.001,\n",
    "    colors=colors,\n",
    "    markers=markers,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
